package api

import (
	"encoding/json"
	"io"
	"net/http"
	"strconv"
	"time"
	
	"github.com/gin-gonic/gin"
	"gitee.com/liumou_site/disk-monitoring/backend/internal/service"
)

// ProcessHandler 进程处理层结构体
type ProcessHandler struct {
	processService service.ProcessService
}

// NewProcessHandler 创建进程处理层实例
func NewProcessHandler(processService service.ProcessService) *ProcessHandler {
	return &ProcessHandler{
		processService: processService,
	}
}

// GetProcessIOStats 获取进程IO统计信息
// @Summary 获取进程IO统计信息
// @Description 获取系统中所有进程的IO统计信息，包括进程名称、PID、读取字节数、写入字节数、读取次数、写入次数等静态数据
// @Tags 进程信息
// @Accept json
// @Produce json
// @Success 200 {array} model.ProcessIOStat "成功返回进程IO统计信息列表"
// @Failure 500 {object} map[string]interface{} "错误响应：{\"error\": \"错误描述\"}"
// @Router /api/process/io [get]
func (h *ProcessHandler) GetProcessIOStats(c *gin.Context) {
	processIOStats, err := h.processService.GetProcessIOStats()
	if err != nil {
		c.JSON(http.StatusInternalServerError, gin.H{"error": err.Error()})
		return
	}
	
	c.JSON(http.StatusOK, processIOStats)
}

// GetTopProcessIOStats 获取IO使用率最高的进程列表
// @Summary 获取IO使用率最高的进程列表
// @Description 获取系统中IO使用率最高的进程列表，按IO活动总量排序，默认返回前10个进程（静态数据）
// @Tags 进程信息
// @Accept json
// @Produce json
// @Param limit query int false "返回的进程数量，默认为10，最大值为50"
// @Success 200 {array} model.ProcessIOStat "成功返回IO使用率最高的进程列表"
// @Failure 400 {object} map[string]interface{} "错误响应：{\"error\": \"参数错误描述\"}"
// @Failure 500 {object} map[string]interface{} "错误响应：{\"error\": \"服务器错误描述\"}"
// @Router /api/process/io/top [get]
func (h *ProcessHandler) GetTopProcessIOStats(c *gin.Context) {
	// 默认获取前10个进程
	limit := 10
	
	// 如果提供了limit参数，则使用该参数
	if limitParam := c.Query("limit"); limitParam != "" {
		if parsedLimit, err := strconv.Atoi(limitParam); err == nil && parsedLimit > 0 {
			limit = parsedLimit
		}
	}
	
	topProcessIOStats, err := h.processService.GetTopProcessIOStats(limit)
	if err != nil {
		c.JSON(http.StatusInternalServerError, gin.H{"error": err.Error()})
		return
	}
	
	c.JSON(http.StatusOK, topProcessIOStats)
}

// GetRealTimeProcessIOData SSE方式获取实时进程IO数据
// @Summary SSE方式获取实时进程IO数据
// @Description 通过SSE方式实时推送进程IO性能数据，包括进程名称、PID、实时IO速度、IO操作次数等，每秒更新一次
// @Tags 进程信息
// @Produce text/event-stream
// @Success 200 {object} model.RealTimeProcessIOData "SSE数据流：包含实时进程IO性能数据"
// @Failure 500 {object} map[string]interface{} "错误响应：{\"error\": \"错误描述\"}"
// @Router /api/process/io/realtime [get]
func (h *ProcessHandler) GetRealTimeProcessIOData(c *gin.Context) {
	// 设置SSE相关头部信息
	c.Header("Content-Type", "text/event-stream")
	c.Header("Cache-Control", "no-cache")
	c.Header("Connection", "keep-alive")
	c.Header("Access-Control-Allow-Origin", "*")
	
	// 创建一个定时器，每隔1秒发送一次数据
	ticker := time.NewTicker(1 * time.Second)
	defer ticker.Stop()
	
	// 监听客户端断开连接
	clientGone := c.Request.Context().Done()
	
	for {
		select {
		case <-clientGone:
			// 客户端断开连接，退出循环
			return
		case <-ticker.C:
			// 获取实时进程IO数据
			realTimeData, err := h.processService.GetRealTimeProcessIOData()
			if err != nil {
				// 发送错误信息
				c.Stream(func(w io.Writer) bool {
					c.SSEvent("error", err.Error())
					return false
				})
				return
			}
			
			// 将数据转换为JSON格式
			data, err := json.Marshal(realTimeData)
			if err != nil {
				c.Stream(func(w io.Writer) bool {
					c.SSEvent("error", err.Error())
					return false
				})
				return
			}
			
			// 发送数据给客户端
			c.Stream(func(w io.Writer) bool {
				c.SSEvent("message", string(data))
				return true
			})
			
			// 确保数据被发送
			c.Writer.Flush()
		}
	}
}